ஜாவாஸ்கிரிப்ட் ஜெனரேட்டர்கள்: இட்டரேட்டர் புரோட்டோகால் மற்றும் அசிங்க் இட்டரேஷனில் தேர்ச்சி

ஜாவாஸ்கிரிப்ட் ஜெனரேட்டர்கள் இட்டரேஷனைக் கட்டுப்படுத்துவதற்கும் அசிங்க்ரோனஸ் செயல்பாடுகளை நிர்வகிப்பதற்கும் ஒரு சக்திவாய்ந்த வழிமுறையை வழங்குகின்றன. அவை இட்டரேட்டர் புரோட்டோகால் மீது கட்டமைக்கப்பட்டு, அசிங்க்ரோனஸ் டேட்டா ஸ்ட்ரீம்களை தடையின்றி கையாள அதை விரிவுபடுத்துகின்றன. இந்த வழிகாட்டி ஜாவாஸ்கிரிப்ட் ஜெனரேட்டர்கள் பற்றிய ஒரு விரிவான கண்ணோட்டத்தை வழங்குகிறது, அவற்றின் முக்கிய கருத்துக்கள், மேம்பட்ட அம்சங்கள் மற்றும் நவீன ஜாவாஸ்கிரிப்ட் மேம்பாட்டில் நடைமுறை பயன்பாடுகள் ஆகியவற்றை உள்ளடக்கியது.

இட்டரேட்டர் புரோட்டோகாலைப் புரிந்துகொள்ளுதல்

இட்டரேட்டர் புரோட்டோகால் என்பது ஜாவாஸ்கிரிப்ட்டில் ஒரு அடிப்படைக் கருத்தாகும், இது ஆப்ஜெக்ட்களை எப்படி இட்டரேட் செய்வது என்பதை வரையறுக்கிறது. இது இரண்டு முக்கிய கூறுகளை உள்ளடக்கியது:

• Iterable: ஒரு இட்டரேட்டரை வழங்கும் ஒரு மெத்தட் (Symbol.iterator) கொண்ட ஒரு ஆப்ஜெக்ட்.
• Iterator: ஒரு next() மெத்தடை வரையறுக்கும் ஒரு ஆப்ஜெக்ட். next() மெத்தட் இரண்டு பண்புகளுடன் ஒரு ஆப்ஜெக்டை வழங்குகிறது: value (வரிசையில் அடுத்த மதிப்பு) மற்றும் done (இட்டரேஷன் முடிந்துவிட்டதா என்பதைக் குறிக்கும் ஒரு பூலியன்).

இதை ஒரு எளிய உதாரணத்துடன் விளக்குவோம்:

            
const myIterable = {
  data: [1, 2, 3],
  [Symbol.iterator]() {
    let index = 0;
    return {
      next: () => {
        if (index < this.data.length) {
          return { value: this.data[index++], done: false };
        } else {
          return { value: undefined, done: true };
        }
      }
    };
  }
};

for (const value of myIterable) {
  console.log(value); // Output: 1, 2, 3
}

            

              
                Copy
              
            
          

இந்த எடுத்துக்காட்டில், myIterable ஒரு இட்டரேபிள் ஆப்ஜெக்ட் ஆகும், ஏனெனில் இது Symbol.iterator மெத்தடைக் கொண்டுள்ளது. Symbol.iterator மெத்தட் ஒரு இட்டரேட்டர் ஆப்ஜெக்டை வழங்குகிறது, அதன் next() மெத்தட் 1, 2, மற்றும் 3 மதிப்புகளை ஒவ்வொன்றாக உருவாக்குகிறது. இட்டரேட் செய்ய வேறு மதிப்புகள் இல்லாதபோது done பண்பு true ஆக மாறும்.

ஜாவாஸ்கிரிப்ட் ஜெனரேட்டர்களை அறிமுகப்படுத்துதல்

ஜெனரேட்டர்கள் ஜாவாஸ்கிரிப்ட்டில் ஒரு சிறப்பு வகை ஃபங்ஷன் ஆகும், அதை இடைநிறுத்தி மீண்டும் இயக்க முடியும். அவை பல அழைப்புகளுக்கு இடையில் அதன் நிலையை பராமரிக்கும் ஒரு ஃபங்ஷனை எழுதுவதன் மூலம் ஒரு இட்டரேட்டிவ் அல்காரிதத்தை வரையறுக்க உங்களை அனுமதிக்கின்றன. ஜெனரேட்டர்கள் function* சிண்டாக்ஸ் மற்றும் yield கீவேர்டைப் பயன்படுத்துகின்றன.

இதோ ஒரு எளிய ஜெனரேட்டர் உதாரணம்:

            
function* numberGenerator() {
  yield 1;
  yield 2;
  yield 3;
}

const generator = numberGenerator();

console.log(generator.next()); // Output: { value: 1, done: false }
console.log(generator.next()); // Output: { value: 2, done: false }
console.log(generator.next()); // Output: { value: 3, done: false }
console.log(generator.next()); // Output: { value: undefined, done: true }

            

              
                Copy
              
            
          

நீங்கள் numberGenerator() ஐ அழைக்கும்போது, அது உடனடியாக ஃபங்ஷன் பாடியை இயக்காது. அதற்கு பதிலாக, அது ஒரு ஜெனரேட்டர் ஆப்ஜெக்டை வழங்குகிறது. generator.next() க்கான ஒவ்வொரு அழைப்பும், ஒரு yield கீவேர்டை சந்திக்கும் வரை ஃபங்ஷனை இயக்குகிறது. yield கீவேர்ட் ஃபங்ஷனை இடைநிறுத்தி, யீல்டு செய்யப்பட்ட மதிப்புடன் ஒரு ஆப்ஜெக்டை வழங்குகிறது. next() மீண்டும் அழைக்கப்படும்போது ஃபங்ஷன் விட்ட இடத்திலிருந்து மீண்டும் தொடங்குகிறது.

ஜெனரேட்டர் ஃபங்ஷன்கள் vs. வழக்கமான ஃபங்ஷன்கள்

ஜெனரேட்டர் ஃபங்ஷன்களுக்கும் வழக்கமான ஃபங்ஷன்களுக்கும் இடையிலான முக்கிய வேறுபாடுகள்:

• ஜெனரேட்டர் ஃபங்ஷன்கள் function க்கு பதிலாக function* ஐப் பயன்படுத்தி வரையறுக்கப்படுகின்றன.
• ஜெனரேட்டர் ஃபங்ஷன்கள் செயல்பாட்டை இடைநிறுத்தி ஒரு மதிப்பை வழங்க yield கீவேர்டைப் பயன்படுத்துகின்றன.
• ஒரு ஜெனரேட்டர் ஃபங்ஷனை அழைப்பது ஒரு ஜெனரேட்டர் ஆப்ஜெக்டை வழங்குகிறது, ஃபங்ஷனின் முடிவை அல்ல.

இட்டரேட்டர் புரோட்டோகாலுடன் ஜெனரேட்டர்களைப் பயன்படுத்துதல்

ஜெனரேட்டர்கள் தானாகவே இட்டரேட்டர் புரோட்டோகாலுக்கு இணங்குகின்றன. இதன் பொருள் நீங்கள் அவற்றை நேரடியாக for...of லூப்களிலும் மற்ற இட்டரேட்டர்-கன்ஸ்யூமிங் ஃபங்ஷன்களிலும் பயன்படுத்தலாம்.

            
function* fibonacciGenerator() {
  let a = 0, b = 1;
  while (true) {
    yield a;
    [a, b] = [b, a + b];
  }
}

const fibonacci = fibonacciGenerator();

for (let i = 0; i < 10; i++) {
  console.log(fibonacci.next().value); // Output: The first 10 Fibonacci numbers
}

            

              
                Copy
              
            
          

இந்த எடுத்துக்காட்டில், fibonacciGenerator() என்பது ஃபிபோனச்சி வரிசையை யீல்டு செய்யும் ஒரு முடிவற்ற ஜெனரேட்டர் ஆகும். நாம் ஒரு ஜெனரேட்டர் இன்ஸ்டன்ஸை உருவாக்கி, முதல் 10 எண்களை அச்சிட அதன் மீது இட்டரேட் செய்கிறோம். இட்டரேஷனைக் கட்டுப்படுத்தாவிட்டால், இந்த ஜெனரேட்டர் எப்போதும் இயங்கும் என்பதை கவனத்தில் கொள்ளவும்.

ஜெனரேட்டர்களுக்குள் மதிப்புகளை அனுப்புதல்

நீங்கள் next() மெத்தடைப் பயன்படுத்தி ஒரு ஜெனரேட்டருக்குள் மதிப்புகளை மீண்டும் அனுப்பலாம். next() க்கு அனுப்பப்பட்ட மதிப்பு yield எக்ஸ்பிரஷனின் முடிவாக மாறும்.

            
function* echoGenerator() {
  const input = yield;
  console.log(`You entered: ${input}`);
}

const echo = echoGenerator();

echo.next(); // Start the generator
echo.next("Hello, World!"); // Output: You entered: Hello, World!

            

              
                Copy
              
            
          

இந்த நிலையில், முதல் next() அழைப்பு ஜெனரேட்டரைத் தொடங்குகிறது. இரண்டாவது next("Hello, World!") அழைப்பு "Hello, World!" என்ற ஸ்டிரிங்கை ஜெனரேட்டருக்குள் அனுப்புகிறது, இது பின்னர் input வேரியபிளுக்கு ஒதுக்கப்படும்.

மேம்பட்ட ஜெனரேட்டர் அம்சங்கள்

yield*: மற்றொரு இட்டரேபிளுக்குப் பணிஒப்படைத்தல்

yield* கீவேர்ட், மற்ற ஜெனரேட்டர்கள் உட்பட, மற்றொரு இட்டரேபிள் ஆப்ஜெக்டிற்கு இட்டரேஷனை ஒப்படைக்க உங்களை அனுமதிக்கிறது.

            
function* subGenerator() {
  yield 4;
  yield 5;
  yield 6;
}

function* mainGenerator() {
  yield 1;
  yield 2;
  yield 3;
  yield* subGenerator();
  yield 7;
  yield 8;
}

const main = mainGenerator();

for (const value of main) {
  console.log(value); // Output: 1, 2, 3, 4, 5, 6, 7, 8
}

            

              
                Copy
              
            
          

yield* subGenerator() வரி, subGenerator() ஆல் யீல்டு செய்யப்பட்ட மதிப்புகளை mainGenerator() இன் வரிசையில் திறம்பட செருகுகிறது.

return() மற்றும் throw() மெத்தட்கள்

ஜெனரேட்டர் ஆப்ஜெக்ட்கள் return() மற்றும் throw() மெத்தட்களையும் கொண்டுள்ளன, அவை ஜெனரேட்டரை முன்கூட்டியே நிறுத்த அல்லது அதற்குள் ஒரு பிழையை எறிய உங்களை அனுமதிக்கின்றன.

            
function* exampleGenerator() {
  try {
    yield 1;
    yield 2;
    yield 3;
  } finally {
    console.log("Cleaning up...");
  }
}

const gen = exampleGenerator();

console.log(gen.next()); // Output: { value: 1, done: false }
console.log(gen.return("Finished")); // Output: Cleaning up...
// Output: { value: 'Finished', done: true }
console.log(gen.next()); // Output: { value: undefined, done: true }


function* errorGenerator() {
  try {
    yield 1;
    yield 2;
  } catch (e) {
    console.error("Error caught:", e);
  }
  yield 3;
}

const errGen = errorGenerator();

console.log(errGen.next()); // Output: { value: 1, done: false }
console.log(errGen.throw(new Error("Something went wrong!"))); // Output: Error caught: Error: Something went wrong!
// Output: { value: 3, done: false }
console.log(errGen.next()); // Output: { value: undefined, done: true }

            

              
                Copy
              
            
          

return() மெத்தட் finally பிளாக்கை (ஏதேனும் இருந்தால்) இயக்கி, done பண்பை true என அமைக்கிறது. throw() மெத்தட் ஜெனரேட்டருக்குள் ஒரு பிழையை எறிகிறது, அதை try...catch பிளாக்கைப் பயன்படுத்திப் பிடிக்கலாம்.

அசிங்க்ரோனஸ் இட்டரேஷன் மற்றும் அசிங்க் ஜெனரேட்டர்கள்

அசிங்க் இட்டரேஷன், அசிங்க்ரோனஸ் டேட்டா ஸ்ட்ரீம்களைக் கையாள இட்டரேட்டர் புரோட்டோகாலை விரிவுபடுத்துகிறது. இது இரண்டு புதிய கருத்துக்களை அறிமுகப்படுத்துகிறது:

• Async Iterable: ஒரு அசிங்க் இட்டரேட்டரை வழங்கும் ஒரு மெத்தட் (Symbol.asyncIterator) கொண்ட ஒரு ஆப்ஜெக்ட்.
• Async Iterator: ஒரு பிராமிஸை வழங்கும் next() மெத்தடை வரையறுக்கும் ஒரு ஆப்ஜெக்ட். அந்த பிராமிஸ் இரண்டு பண்புகளுடன் ஒரு ஆப்ஜெக்டைக் கொண்டு தீர்க்கப்படுகிறது: value (வரிசையில் அடுத்த மதிப்பு) மற்றும் done (இட்டரேஷன் முடிந்துவிட்டதா என்பதைக் குறிக்கும் ஒரு பூலியன்).

அசிங்க் ஜெனரேட்டர்கள், அசிங்க் இட்டரேட்டர்களை உருவாக்க ஒரு வசதியான வழியை வழங்குகின்றன. அவை async function* சிண்டாக்ஸ் மற்றும் await கீவேர்டைப் பயன்படுத்துகின்றன.

            
async function* asyncNumberGenerator() {
  await delay(1000); // Simulate an asynchronous operation
  yield 1;
  await delay(1000);
  yield 2;
  await delay(1000);
  yield 3;
}

function delay(ms) {
  return new Promise(resolve => setTimeout(resolve, ms));
}

async function main() {
  const asyncGenerator = asyncNumberGenerator();

  for await (const value of asyncGenerator) {
    console.log(value); // Output: 1, 2, 3 (with 1 second delay between each)
  }
}

main();

            

              
                Copy
              
            
          

இந்த எடுத்துக்காட்டில், asyncNumberGenerator() என்பது ஒரு அசிங்க் ஜெனரேட்டர் ஆகும், இது ஒவ்வொரு எண்ணுக்கும் இடையில் 1-வினாடி தாமதத்துடன் எண்களை யீல்டு செய்கிறது. அசிங்க் ஜெனரேட்டரின் மீது இட்டரேட் செய்ய for await...of லூப் பயன்படுத்தப்படுகிறது. await கீவேர்ட் ஒவ்வொரு மதிப்பும் அசிங்க்ரோனஸ் முறையில் செயலாக்கப்படுவதை உறுதி செய்கிறது.

ஒரு அசிங்க் இட்டரேபிளை கைமுறையாக உருவாக்குதல்

அசிங்க் ஜெனரேட்டர்கள் பொதுவாக அசிங்க் இட்டரேபிள்களை உருவாக்க எளிதான வழியாக இருந்தாலும், நீங்கள் அவற்றை Symbol.asyncIterator ஐப் பயன்படுத்தி கைமுறையாகவும் உருவாக்கலாம்.

            
const myAsyncIterable = {
  data: [1, 2, 3],
  [Symbol.asyncIterator]() {
    let index = 0;
    return {
      next: async () => {
        await delay(500);
        if (index < this.data.length) {
          return { value: this.data[index++], done: false };
        } else {
          return { value: undefined, done: true };
        }
      }
    };
  }
};

async function main2() {
  for await (const value of myAsyncIterable) {
    console.log(value); // Output: 1, 2, 3 (with 0.5 second delay between each)
  }
}

main2();

            

              
                Copy
              
            
          

ஜெனரேட்டர்கள் மற்றும் அசிங்க் ஜெனரேட்டர்களுக்கான பயன்பாட்டு வழக்குகள்

ஜெனரேட்டர்கள் மற்றும் அசிங்க் ஜெனரேட்டர்கள் பல்வேறு சூழ்நிலைகளில் பயனுள்ளதாக இருக்கும், அவற்றுள் சில:

• சோம்பேறி மதிப்பீடு (Lazy Evaluation): தேவைக்கேற்ப மதிப்புகளை உருவாக்குதல், இது செயல்திறனை மேம்படுத்தி நினைவகப் பயன்பாட்டைக் குறைக்கும், குறிப்பாக பெரிய தரவுத்தொகுப்புகளைக் கையாளும்போது. உதாரணமாக, ஒரு பெரிய CSV கோப்பை முழுமையாக நினைவகத்தில் ஏற்றாமல் வரி வரியாக செயலாக்குதல்.
• நிலை மேலாண்மை (State Management): பல ஃபங்ஷன் அழைப்புகளுக்கு இடையில் நிலையை பராமரித்தல், இது சிக்கலான அல்காரிதங்களை எளிதாக்கும். உதாரணமாக, வெவ்வேறு நிலைகள் மற்றும் மாற்றங்களைக் கொண்ட ஒரு விளையாட்டை செயல்படுத்துதல்.
• அசிங்க்ரோனஸ் டேட்டா ஸ்ட்ரீம்கள்: ஒரு சர்வரிலிருந்து வரும் டேட்டா அல்லது பயனர் உள்ளீடு போன்ற அசிங்க்ரோனஸ் டேட்டா ஸ்ட்ரீம்களைக் கையாளுதல். உதாரணமாக, ஒரு டேட்டாபேஸ் அல்லது ஒரு நிகழ்நேர ஏபிஐ (API) இலிருந்து டேட்டாவை ஸ்ட்ரீம் செய்தல்.
• கட்டுப்பாட்டு ஓட்டம் (Control Flow): கோரூட்டீன்கள் போன்ற தனிப்பயன் கட்டுப்பாட்டு ஓட்ட வழிமுறைகளை செயல்படுத்துதல்.
• சோதனை (Testing): யூனிட் டெஸ்ட்களில் சிக்கலான அசிங்க்ரோனஸ் சூழ்நிலைகளை உருவகப்படுத்துதல்.

பல்வேறு பிராந்தியங்களில் உள்ள உதாரணங்கள்

ஜெனரேட்டர்கள் மற்றும் அசிங்க் ஜெனரேட்டர்கள் வெவ்வேறு பிராந்தியங்களிலும் சூழல்களிலும் எவ்வாறு பயன்படுத்தப்படலாம் என்பதற்கான சில உதாரணங்களைக் காண்போம்:

• மின்-வணிகம் (உலகளாவியது): ஒரு அசிங்க் ஜெனரேட்டரைப் பயன்படுத்தி ஒரு தரவுத்தளத்திலிருந்து பகுதிகளாக முடிவுகளைப் பெறும் ஒரு தயாரிப்பு தேடலைச் செயல்படுத்துதல். இது பயனரின் இருப்பிடம் அல்லது நெட்வொர்க் வேகத்தைப் பொருட்படுத்தாமல், முடிவுகள் கிடைக்கும்போது UI ஐ படிப்படியாகப் புதுப்பிக்க அனுமதிக்கிறது, இது பயனர் அனுபவத்தை மேம்படுத்துகிறது.
• நிதிப் பயன்பாடுகள் (ஐரோப்பா): கணக்கீடுகளைச் செய்வதற்கும் அறிக்கைகளை திறமையாக உருவாக்குவதற்கும் ஜெனரேட்டர்களைப் பயன்படுத்தி பெரிய நிதித் தரவுத்தொகுப்புகளை (எ.கா., பங்குச் சந்தை தரவு) செயலாக்குதல். இது ஒழுங்குமுறை இணக்கம் மற்றும் இடர் மேலாண்மைக்கு முக்கியமானது.
• தளவாடங்கள் (ஆசியா): ஷிப்மென்ட்களைக் கண்காணிக்கவும் விநியோக வழிகளை மேம்படுத்தவும் அசிங்க் ஜெனரேட்டர்களைப் பயன்படுத்தி ஜிபிஎஸ் சாதனங்களிலிருந்து நிகழ்நேர இருப்பிடத் தரவை ஸ்ட்ரீம் செய்தல். இது சிக்கலான தளவாட சவால்களைக் கொண்ட ஒரு பிராந்தியத்தில் செயல்திறனை மேம்படுத்தவும் செலவுகளைக் குறைக்கவும் உதவும்.
• கல்வி (ஆப்பிரிக்கா): அசிங்க் ஜெனரேட்டர்களைப் பயன்படுத்தி உள்ளடக்கத்தை மாறும் வகையில் பெறும் ஊடாடும் கற்றல் தொகுதிகளை உருவாக்குதல். இது தனிப்பயனாக்கப்பட்ட கற்றல் அனுபவங்களை அனுமதிக்கிறது மற்றும் குறைந்த அலைவரிசை உள்ள பகுதிகளில் உள்ள மாணவர்கள் கல்வி வளங்களை அணுகுவதை உறுதி செய்கிறது.
• சுகாதாரம் (அமெரிக்கா): முக்கிய அறிகுறிகளைக் கண்காணிக்கவும் நிகழ்நேரத்தில் முரண்பாடுகளைக் கண்டறியவும் அசிங்க் ஜெனரேட்டர்களைப் பயன்படுத்தி மருத்துவ சென்சார்களிலிருந்து நோயாளி தரவை செயலாக்குதல். இது நோயாளியின் பராமரிப்பை மேம்படுத்தவும் மருத்துவப் பிழைகளின் அபாயத்தைக் குறைக்கவும் உதவும்.

ஜெனரேட்டர்களைப் பயன்படுத்துவதற்கான சிறந்த நடைமுறைகள்

• இட்டரேட்டிவ் அல்காரிதங்களுக்கு ஜெனரேட்டர்களைப் பயன்படுத்துங்கள்: இட்டரேஷன் மற்றும் நிலை மேலாண்மை சம்பந்தப்பட்ட அல்காரிதங்களுக்கு ஜெனரேட்டர்கள் மிகவும் பொருத்தமானவை.
• அசிங்க்ரோனஸ் டேட்டா ஸ்ட்ரீம்களுக்கு அசிங்க் ஜெனரேட்டர்களைப் பயன்படுத்துங்கள்: அசிங்க்ரோனஸ் டேட்டா ஸ்ட்ரீம்களைக் கையாள்வதற்கும் அசிங்க்ரோனஸ் செயல்பாடுகளைச் செய்வதற்கும் அசிங்க் ஜெனரேட்டர்கள் சிறந்தவை.
• பிழைகளைச் சரியாகக் கையாளவும்: ஜெனரேட்டர்கள் மற்றும் அசிங்க் ஜெனரேட்டர்களுக்குள் பிழைகளைக் கையாள try...catch பிளாக்குகளைப் பயன்படுத்தவும்.
• தேவைப்படும்போது ஜெனரேட்டர்களை நிறுத்தவும்: தேவைப்படும்போது ஜெனரேட்டர்களை முன்கூட்டியே நிறுத்த return() மெத்தடைப் பயன்படுத்தவும்.
• செயல்திறன் தாக்கங்களைக் கருத்தில் கொள்ளுங்கள்: ஜெனரேட்டர்கள் சில சந்தர்ப்பங்களில் செயல்திறனை மேம்படுத்த முடியும் என்றாலும், அவை கூடுதல் சுமையையும் அறிமுகப்படுத்தலாம். உங்கள் குறிப்பிட்ட பயன்பாட்டு வழக்கிற்கு ஜெனரேட்டர்கள் சரியான தேர்வாக இருப்பதை உறுதிசெய்ய உங்கள் குறியீட்டை முழுமையாகச் சோதிக்கவும்.

முடிவுரை

ஜாவாஸ்கிரிப்ட் ஜெனரேட்டர்கள் மற்றும் அசிங்க் ஜெனரேட்டர்கள் நவீன ஜாவாஸ்கிரிப்ட் பயன்பாடுகளை உருவாக்குவதற்கான சக்திவாய்ந்த கருவிகள். இட்டரேட்டர் புரோட்டோகாலைப் புரிந்துகொண்டு yield மற்றும் await கீவேர்டுகளில் தேர்ச்சி பெறுவதன் மூலம், நீங்கள் மேலும் திறமையான, பராமரிக்கக்கூடிய மற்றும் அளவிடக்கூடிய குறியீட்டை எழுதலாம். நீங்கள் பெரிய தரவுத்தொகுப்புகளைச் செயலாக்கினாலும், அசிங்க்ரோனஸ் செயல்பாடுகளை நிர்வகித்தாலும், அல்லது சிக்கலான அல்காரிதங்களைச் செயல்படுத்தினாலும், ஜெனரேட்டர்கள் பரந்த அளவிலான புரோகிராமிங் சவால்களைத் தீர்க்க உங்களுக்கு உதவும்.

இந்த விரிவான வழிகாட்டி, ஜெனரேட்டர்களைத் திறம்படப் பயன்படுத்தத் தேவையான அறிவையும் எடுத்துக்காட்டுகளையும் உங்களுக்கு வழங்கியுள்ளது. எடுத்துக்காட்டுகளுடன் பரிசோதனை செய்யுங்கள், வெவ்வேறு பயன்பாட்டு வழக்குகளை ஆராயுங்கள், உங்கள் திட்டங்களில் ஜாவாஸ்கிரிப்ட் ஜெனரேட்டர்களின் முழு திறனையும் திறந்திடுங்கள்.